package com.irdstudio.apicenter.gateway.comm;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import com.irdstudio.apicenter.gateway.util.Convert;

/**
 * MACCS 通讯报文包
 * @author 李广明
 * @version 1.1
 * @modify 2015-05-24
 * 		1.可使用Java 5中支持高并发高吞吐量的线程安全的HashMap
 * 		2.以MAP中存放键值对的形式进行组包,区分大小字
 */
public class MaccsPacket {

	// 定义存放变量值的容器
	private Map<String, Object> keyValues = null;

	/**
	 *  默认构造函数
	 *  非线程安全,由于每个请求过来均为线程
	 *  每个线程均有一份通讯报文包,所以默认为非线程安全
	 */
	public MaccsPacket() {
		keyValues = new HashMap<String, Object>();
	}
	
	/**
	 * 根据选择构造(如果传false，则构造为非线程安全的MAP)
	 * 如果不是在并发环境使用，可以使用hashMap
	 * @param isThreadSafe
	 */
	public MaccsPacket(boolean isThreadSafe) {
		if (isThreadSafe) {
			keyValues = new ConcurrentHashMap<String, Object>();
		} else {
			keyValues = new HashMap<String, Object>();
		}
	}
	
	/**
	 * 用dataMap构造MaccsPacket
	 * @param dataMap
	 */
	public MaccsPacket(Map<String, Object> dataMap) {
		keyValues = dataMap;
	}
	
	/**
	 * 向容器中增加变量
	 * @param varName
	 * @param varValue
	 */
	public void addVariable(String keyName,String varValue){		
		
		if(null == varValue){
			keyValues.put(keyName,"");
		} else {
			keyValues.put(keyName,varValue);
		}
	}
	
	/**
	 * 向容器顺中存放对象
	 * @param keyName
	 * @param varValue
	 */
	public void addVariable(String keyName,Object varValue){
		
		if(null == varValue){
			keyValues.put(keyName,"");
		} else {
			keyValues.put(keyName,varValue);
		}
	}	
	
	/**
	 * 从容器中取得变量的值
	 * @param keyName
	 */
	public String getValue(String keyName){	
		Object objR = keyValues.get(keyName);
		if(objR == null) return "";
		return objR.toString();
	}
	
	/**
	 * 从容器中取得对象
	 * @param keyName
	 * @return
	 */
	public Object getObject(String keyName){
		return keyValues.get(keyName);
	}
	
	/**
	 * 返回整型值
	 * @param keyName
	 * @return
	 */
	public int getIntValue(String keyName) {
		Object value = keyValues.get(keyName.toUpperCase());
		if(value == null) return 0;
		return Convert.StrToInt(value.toString(), 0);
	}
	
	/**
	 * 从容器中取得变量的值,如果容器不存在该键值,且默认值不为空,则返回默认值
	 * @param keyName
	 */
	public String getValue(String keyName,String defaultv){
		
		Object objR = keyValues.get(keyName);
		if(objR == null&&defaultv!=null){
			return defaultv;
		}else if (objR == null&&defaultv==null){
			 return "";
		}else{
			return objR.toString();
		} 
	}
	
	/**
	 * 多态的从容器中取得变量的值
	 * @param obj
	 * @return
	 */
	public String getValue(Object obj){
		if(obj == null) return "";
		return getValue(obj.toString().toUpperCase());
	}
		
	public boolean isExist(Object obj){
		if(obj == null) return false;
		if(keyValues.get(obj) == null){
			return false;
		}
		return true;
	}
	
	/**
	 * 如果存在变量,先删除,后填入
	 * 如果不存在变量,直接填入
	 * @param keyName
	 * @param value
	 */
	public void merge(String keyName,String value){
		
		Object objR = keyValues.get(keyName);
		if(objR == null) keyValues.put(keyName, value);
		else {
			keyValues.remove(objR);
			keyValues.put(keyName, value);
		}
	}
	
	/**
	 * 删除一个键值
	 * @param keyName
	 */
	public void remove(String keyName) {
		if (keyName == null)
			return;
		keyValues.remove(keyName.toUpperCase());
	}
	
	/**
	 * 清空存储的数据
	 */
	public void clear(){
		keyValues.clear();
	}
	
	/**
	 * 将本类的核心,即用于存放数据的MAP返回
	 * @return
	 */
	public Map<String, Object> getMap(){
		return keyValues;
	}
	
	public String toString() {
		StringBuffer sb = new StringBuffer("{");
		for (Iterator<?> iter = this.getMap().keySet().iterator(); iter
				.hasNext();) {
			String f = (String) iter.next();
			sb.append(f).append("=").append(this.getValue(f)).append(",");// .append("\n");
		}
		sb.deleteCharAt(sb.length() - 1);
		sb.append("}");
		return sb.toString();
	}
}